package com.itheima.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.itheima.constant.MessageConstant;
import com.itheima.dao.MemberDao;
import com.itheima.dao.OrderDao;
import com.itheima.dao.OrderSettingDao;
import com.itheima.entity.PageResult;
import com.itheima.entity.Result;
import com.itheima.pojo.Member;
import com.itheima.pojo.Order;
import com.itheima.pojo.OrderSetting;
import com.itheima.service.OrderService;
import com.itheima.utils.DateUtils;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service(interfaceClass = OrderService.class)
@Transactional
public class OrderServiceImpl implements OrderService {

    //自动注入
    @Autowired
    private OrderDao orderDao;

    //注入OrderSettingDao
    @Autowired
    private OrderSettingDao orderSettingDao;

    //注入MemberDao
    @Autowired
    private MemberDao memberDao;

    //上传文件
    @Override
    public Result add(Map<String, Object> map) throws Exception {
        //1、检查用户所选择的预约日期是否已经提前进行了预约设置，如果没有设置则无法进行预约
        //获取预约日期，查询预约日期是否已经设置，如果没有设置，就预约失败
        String orderDate = (String) map.get("orderDate");
        OrderSetting orderSetting = orderSettingDao.findByOrderDate(DateUtils.parseString2Date(orderDate));
        if (orderSetting == null) {
            //预约信息为空，就证明没有设置预约信息
            return new Result(false, MessageConstant.SELECTED_DATE_CANNOT_ORDER);
        }

        //2、检查用户所选择的预约日期是否已经约满，如果已经约满则无法预约
        //可预约人数
        int number = orderSetting.getNumber();
        //已预约人数
        int reservations = orderSetting.getReservations();
        //判断是否已经约满
        if (reservations >= number) {
            //已经约满，无法预约
            return new Result(false, MessageConstant.ORDER_FULL);
        }

        //3、检查用户是否重复预约（同一个用户在同一天预约了同一个套餐），如果是重复预约则无法完成再次预约
        //先查询当前会员的信息  -- 通过手机号进行查询
        String telephone = (String) map.get("telephone");
        Member member = memberDao.findByTelephone(telephone);
        if (member != null) {
            //获取会员ID
            Integer memberId = member.getId();
            //获取预约日期（从传入的参数（前台发送的）中获取）
            Date orderDate_member = DateUtils.parseString2Date(orderDate);
            //获取当前预约的套餐ID（从传入的参数（前台发送的）中获取）
            String setmealId = (String) map.get("setmealId");
            //查询此预约信息，是否存在(会员的ID,预约日期，预约套餐ID)
            Order order = new Order(memberId, orderDate_member, Integer.parseInt(setmealId));
            Order orderByCondition = orderDao.findByCondition(order);
            //判断
            if (orderByCondition != null) {
                //已经预约，不可以重复预约
                return new Result(false, MessageConstant.HAS_ORDERED);
            }
        } else {
            //4、检查当前用户是否为会员，如果是会员则直接完成预约，如果不是会员则自动完成注册并进行预约
            //通过手机号没有查询到响应的会员信息，所以没有会员
            //获取预约人信息
            String name = (String) map.get("name");
            String sex = (String) map.get("sex");
            String idCard = (String) map.get("idCard");
            member = new Member();
            member.setName(name);
            member.setSex(sex);
            member.setRegTime(new Date());
            member.setPhoneNumber(telephone);
            member.setIdCard(idCard);
            //添加预约信息之前先添加会员信息
            //自动完成会员注册
            memberDao.add(member);
        }
        //5、预约成功，更新当日的已预约人数
        //添加预约信息
        Order order = new Order();
        //设置会员ID
        order.setMemberId(member.getId());
        //设置预约日期（前台发送的数据）
        order.setOrderDate(DateUtils.parseString2Date(orderDate));
        //到诊状态
        order.setOrderStatus(Order.ORDERSTATUS_NO);
        //预约类型
        order.setOrderType(Order.ORDERTYPE_WEIXIN);
        //套餐ID
        order.setSetmealId(Integer.parseInt((String) map.get("setmealId")));
        //添加预约信息
        orderDao.add(order);


        //更新预约人数
        orderSetting.setReservations(orderSetting.getReservations());
        orderSettingDao.editReservationsByOrderDate(orderSetting);
        return new Result(true, MessageConstant.ORDER_SUCCESS, order.getId());
    }

    /**
     * fxw
     * @param map
     * @param setmealId
     * @return
     * @throws Exception
     */
    @Override
    public Result addOrder_fxw(Map<String, Object> map, String setmealId) throws Exception {
        try {
            //1.检查当前用户所选择的预约日期是否已经提前进行了预约设置,如果没有设置则无法进行预约
            //获得用户所选择的日期
            String orderDate = (String) map.get("orderDate");
            //调用Dao,查询数据库
            OrderSetting orderSetting = orderSettingDao.findByOrderDate(DateUtils.parseString2Date(orderDate));
            if (orderSetting == null) {//没有查询到,没有预约设置,无法进行预约
                return new Result(false, MessageConstant.SELECTED_DATE_CANNOT_ORDER);
            }
            //2.检查当前用户所选择的预约日期是否已经约满,如果已经约满则无法预约
            if (orderSetting.getReservations() >= orderSetting.getNumber()) {
                //如果预约数已经大于可预约数,就证明已经约满
                return new Result(false, MessageConstant.ORDER_FULL);
            }

            //3、检查用户是否重复预约（同一个用户在同一天预约了同一个套餐），如果是重复预约则无法完成再次预约
            //先查询当前会员的信息  -- 通过手机号进行查询
            //先获取手机号
            String phoneNumber = (String) map.get("telephone");
            Member member = memberDao.findByTelephone(phoneNumber);
            if (member != null) {
                //证明已经注册信息
                //获取信息,进行添加预约信息
                //获取会员ID
                Integer member_id = member.getId();
                Date orderDate_member = DateUtils.parseString2Date(orderDate);
                //查询此预约信息,是否存在(会员ID,预约日期(前台发送的数据),预约套餐ID(前台发送的))
                Order order = new Order(member_id, orderDate_member, Integer.parseInt(setmealId));
                Order orderByCondition = orderDao.findByCondition(order);
                if (orderByCondition != null) {
                    //已经预约,不可以重复预约
                    return new Result(false, MessageConstant.HAS_ORDERED);
                }
            } else {//member为空
                //4.检查当前用户是否为会员,如果是会员则直接完成预约,如果不是会员则自动完成注册并进行预约
                //获取预约人信息
                member = new Member();
                //设置手机号
                member.setPhoneNumber(phoneNumber);
                //设置注册日期
                member.setRegTime(new Date());
                //设置姓名
                member.setName((String) map.get("memberName"));

                //添加预约信息之前先添加会员信息
                memberDao.add(member);
            }

            //5.预约成功,更新当日的已预约人数
            //添加预约信息
            Order order = new Order();
            //设置会员ID
            order.setMemberId(member.getId());
            //设置预约日期
            order.setOrderDate(DateUtils.parseString2Date(orderDate));
            //设置预约类型
            order.setOrderType(Order.ORDERTYPE_TELEPHONE);
            //设置预约状态
            order.setOrderStatus(Order.ORDERSTATUS_NO);
            //设置套餐的ID
            order.setSetmealId(Integer.parseInt(setmealId));
            //添加预约信息
            orderDao.add(order);

            //更新预约人数
            orderSetting.setReservations(orderSetting.getReservations());
            orderSettingDao.editReservationsByOrderDate(orderSetting);
            return new Result(true, MessageConstant.ORDER_SUCCESS);
        }catch (Exception e){
            return new Result(false, MessageConstant.ORDER_FALL);
        }
    }

    @Override
    public Map findById(String id) throws Exception {
        Map memberInfo = orderDao.findById(id);
        Date orderDate = (Date) memberInfo.get("orderDate");
        memberInfo.put("orderDate", DateUtils.parseDate2String(orderDate));
        return memberInfo;
    }


    //根据条件查询信息
    @Override
    public PageResult findPage(Map<String,Object> map) throws Exception {
            //当前页
            Integer currentPage = (Integer) map.get("currentPage");
            //每页显示多少条
            Integer pageSize = (Integer) map.get("pageSize");

            //获取请求的日期
            List<String> queryDate = (List<String>) map.get("queryDate");
            //日期范围 -- 开始日期
            String queryBefore = null;
            //日期范围 -- 结束日期
            String queryAfter = null;
            if (queryDate != null) {
                //赋值 -- 开始日期
                queryBefore = queryDate.get(0);
                //赋值 -- 结束日期
                queryAfter = queryDate.get(1);
            }
            map.put("queryBefore", queryBefore);
            map.put("queryAfter", queryAfter);


            //分页插件
            PageHelper.startPage(currentPage, pageSize);
            //调用orderDao查询
            Page<Map> orderInfo = orderDao.findPage(map);

            //总条数
            long total = orderInfo.getTotal();
            //数据
            List<Map> result = orderInfo.getResult();
            for (Map resultMap : result) {
                Date resultOrderDate = (Date) resultMap.get("orderDate");
                String orderDate = DateUtils.parseDate2String(resultOrderDate);
                resultMap.put("orderDate",orderDate);
            }

            return new PageResult(total, result);

    }

    @Override
    public Integer findCountByDate(String date) {
        Integer visitCount = orderDao.findCountByDate(date);
        if (visitCount == null){
            return 0;
        }else {
            return visitCount;
        }
    }

    @Override
    public List<Map<String, Object>> findCountByDuring(String date1, String date2) {
        return orderDao.findCountByDuring(date1,date2);
    }

    /**
     * 编辑预约信息
     * @param map
     * @param setmealId
     * @param orderId
     * @return
     */
    @Override
    public Result editOrder(Map<String, Object> map, String setmealId, String orderId) throws Exception {
        //会员手机号
        String telephone = (String) map.get("telephone");
        //会员姓名
        String memberName = (String) map.get("memberName");
        //根据预约ID 修改 会员表中的会员信息
        orderDao.editMemberInfoByOrderId(orderId,telephone,memberName);

        //获取预约日期
        String orderDate = (String) map.get("orderDate");
        Date Order_Date = DateUtils.parseString2Date(orderDate);
        //1.检查当前用户所选择的预约日期是否已经提前进行了预约设置,如果没有设置则无法进行预约
        //获得用户所选择的日期
        //调用Dao,查询数据库
        OrderSetting orderSetting = orderSettingDao.findByOrderDate(DateUtils.parseString2Date(orderDate));
        if (orderSetting == null) {//没有查询到,没有预约设置,无法进行预约
            return new Result(false, MessageConstant.SELECTED_DATE_CANNOT_ORDER);
        }

        //修改预约信息之前先查询原有的预约日期,(为后面修改预约人数做准备)
            //通过预约ID 查找到 修改之前的预约日期
        Order order = orderDao.findOrderById(orderId);
        if (order == null){
            return new Result(false,"没有查询到响应的预约信息");
        }
         //不等于空，就证明编辑的信息存在
        //根据预约ID 修改 预约表中的套餐ID和预约日期
        orderDao.editSetmealIdBOrderId(orderId,setmealId,Order_Date);
        //编辑预约成功后，修改预约设置表中的预约人数 现在的预约日期 + 1 ，原来的日期 -1
            //原来的日期  预约人数 -1
        Date Reduce_OrderDate = order.getOrderDate();
        orderSettingDao.ReservationsReduceByOrderDate(Reduce_OrderDate);
            //现在修改的日期 预约人数 +1
        orderSettingDao.ReservationsPlusByOrderDate(Order_Date);

        return new Result(true,MessageConstant.EDIT_ORDERINFO_SUCCESS);
    }

    /**
     * 修改预约状态信息
     * @param orderStatus
     * @param orderId
     */
    @Override
    public void editOrderStatus(String orderStatus, Integer orderId) {
        orderDao.editOrderStatus(orderId,orderStatus);
    }

    @Override
    public Map getOrderInfo(String memberId) throws Exception {
        Map memberInfo = orderDao.findByMemberId(memberId);

        Date orderDate = (Date) memberInfo.get("orderDate");

        memberInfo.put("orderDate", DateUtils.parseDate2String(orderDate));
        return memberInfo;
    }

}
